home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2007 December / PCWKCD1207B.iso / Blogowanie poza sfera / Flock 0.9.1.3 stable / flock-0.9.1.3.en-US.win32.exe / flock / chrome / browser.jar / content / browser / bookmarks / microsummaryPicker.js < prev    next >
Text File  |  2006-08-23  |  11KB  |  307 lines
  1. //* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
  2. /* ***** BEGIN LICENSE BLOCK *****
  3.  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  4.  *
  5.  * The contents of this file are subject to the Mozilla Public License Version
  6.  * 1.1 (the "License"); you may not use this file except in compliance with
  7.  * the License. You may obtain a copy of the License at
  8.  * http://www.mozilla.org/MPL/
  9.  *
  10.  * Software distributed under the License is distributed on an "AS IS" basis,
  11.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12.  * for the specific language governing rights and limitations under the
  13.  * License.
  14.  *
  15.  * The Original Code is Microsummarizer.
  16.  *
  17.  * The Initial Developer of the Original Code is Mozilla.
  18.  * Portions created by the Initial Developer are Copyright (C) 2006
  19.  * the Initial Developer. All Rights Reserved.
  20.  *
  21.  * Contributor(s):
  22.  *   Myk Melez <myk@mozilla.org>
  23.  *
  24.  * Alternatively, the contents of this file may be used under the terms of
  25.  * either the GNU General Public License Version 2 or later (the "GPL"), or
  26.  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  27.  * in which case the provisions of the GPL or the LGPL are applicable instead
  28.  * of those above. If you wish to allow use of your version of this file only
  29.  * under the terms of either the GPL or the LGPL, and not to allow others to
  30.  * use your version of this file under the terms of the MPL, indicate your
  31.  * decision by deleting the provisions above and replace them with the notice
  32.  * and other provisions required by the GPL or the LGPL. If you do not delete
  33.  * the provisions above, a recipient may use your version of this file under
  34.  * the terms of any one of the MPL, the GPL or the LGPL.
  35.  *
  36.  * ***** END LICENSE BLOCK ***** */
  37.  
  38. // XXX Synchronize these values with the VARIANT constants in Places code?
  39. const ADD_BOOKMARK_MODE = 0;
  40. const EDIT_BOOKMARK_MODE = 1;
  41.  
  42. const Cc = Components.classes;
  43. const Ci = Components.interfaces;
  44.  
  45. var MicrosummaryPicker = {
  46.  
  47.   // The microsummary service.
  48.   __mss: null,
  49.   get _mss() {
  50.     if (!this.__mss)
  51.       this.__mss = Cc["@mozilla.org/microsummary/service;1"].
  52.                    getService(Ci.nsIMicrosummaryService);
  53.     return this.__mss;
  54.   },
  55.  
  56.   // The IO service.
  57.   __ios: null,
  58.   get _ios() {
  59.     if (!this.__ios)
  60.       this.__ios = Cc["@mozilla.org/network/io-service;1"].
  61.                    getService(Ci.nsIIOService);
  62.     return this.__ios;
  63.   },
  64.  
  65.   // The URI of the page being bookmarked.
  66.   get _pageURI() {
  67.     if (this._mode == ADD_BOOKMARK_MODE)
  68.       return this._ios.newURI(gArg.url, null, null);
  69.     else if (this._mode == EDIT_BOOKMARK_MODE) {
  70.       var uriResource = BMDS.GetTarget(gResource, gProperties[1], true);
  71.       if (!uriResource)
  72.         return null;
  73.  
  74.       // The URI spec will be the empty string if the user opened the bookmark
  75.       // properties dialog via the "New Bookmark" command.
  76.       var uriSpec = uriResource.QueryInterface(Ci.nsIRDFLiteral).Value;
  77.       if (!uriSpec)
  78.         return null;
  79.  
  80.       // The IO Service will throw an exception if it can't convert the spec
  81.       // into an nsIURI object.
  82.       var uri;
  83.       try {
  84.         uri = this._ios.newURI(uriSpec, null, null);
  85.       }
  86.       catch(e) {
  87.         return null;
  88.       }
  89.  
  90.       return uri;
  91.     }
  92.  
  93.     return null;
  94.   },
  95.  
  96.   // The unique identifier for the bookmark.  If we're adding a bookmark,
  97.   // this may not exist yet.
  98.   get _bookmarkID() {
  99.     if (this._mode == ADD_BOOKMARK_MODE && typeof gResource == "undefined")
  100.         return null;
  101.  
  102.     return gResource;
  103.   },
  104.  
  105.   _microsummaries: null,
  106.  
  107.   get _mode() {
  108.     if ("gArg" in window)
  109.       return ADD_BOOKMARK_MODE;
  110.     else if ("gProperties" in window)
  111.       return EDIT_BOOKMARK_MODE;
  112.  
  113.     return null;
  114.   },
  115.  
  116.   /*
  117.    * Whether or not the microsummary picker is enabled for this bookmark.
  118.    * The picker is enabled for regular pages.  It's disabled for livemarks,
  119.    * separators, folders, or when bookmarking multiple tabs.
  120.    *
  121.    * @returns boolean true if the picker is enabled; false otherwise
  122.    *
  123.    */
  124.   get enabled() {
  125.     if (this._mode == ADD_BOOKMARK_MODE) {
  126.       // If we're adding a bookmark, we only have to worry about livemarks
  127.       // and bookmarking multiple tabs.
  128.       if ("feedURL" in gArg || gArg.bBookmarkAllTabs)
  129.         return false;
  130.     }
  131.     else if (this._mode == EDIT_BOOKMARK_MODE) {
  132.       // If we're modifying a bookmark, it could be a livemark, separator,
  133.       // folder, or regular page.  The picker is only enabled for regular pages.
  134.       var isLivemark = BookmarksUtils.resolveType(gResource) == "Livemark";
  135.       var isSeparator = BookmarksUtils.resolveType(gResource) == "BookmarkSeparator";
  136.       var isContainer = RDFCU.IsContainer(BMDS, gResource);
  137.       if (isLivemark || isSeparator || isContainer)
  138.         return false;
  139.     }
  140.     else {
  141.       // We should never get to this point, since we're only being used
  142.       // in the Add Bookmark and Bookmark Properties dialogs, but if we're here
  143.       // for some reason, be conservative and assume the picker is disabled.
  144.       return false;
  145.     }
  146.   
  147.     // We haven't found a reason to disable the picker, so say it's enabled.
  148.     return true;
  149.   },
  150.  
  151.   init: function MSP_init() {
  152.     // Set the label of the menu item representing the user-entered name.
  153.     this._updateUserEnteredNameItem();
  154.  
  155.     if (this._pageURI) {
  156.       this._microsummaries = this._mss.getMicrosummaries(this._pageURI, this._bookmarkID);
  157.       this._microsummaries.addObserver(this._observer);
  158.       this.rebuild();
  159.     }
  160.   },
  161.  
  162.   destroy: function MSP_destroy() {
  163.     if (this._pageURI && this._microsummaries)
  164.       this._microsummaries.removeObserver(this._observer);
  165.   },
  166.  
  167.   rebuild: function MSP_rebuild() {
  168.     var microsummaryMenuList = document.getElementById("name");
  169.     var microsummaryMenuPopup = document.getElementById("microsummaryMenuPopup");
  170.   
  171.     // Save a reference to the active item (i.e. the item the user is hovering
  172.     // over), if any, so we can reactivate it after the rebuild.
  173.     var activeMicrosummary;
  174.     if (microsummaryMenuList.menuBoxObject.activeChild)
  175.       activeMicrosummary = microsummaryMenuList.menuBoxObject.activeChild.microsummary;
  176.  
  177.     // Remove old items from the menu, except for the first item, which holds
  178.     // the user-entered name, and the second item, which separates and labels
  179.     // the microsummaries below it.
  180.     while (microsummaryMenuPopup.childNodes.length > 2)
  181.       microsummaryMenuPopup.removeChild(microsummaryMenuPopup.lastChild);
  182.   
  183.     var enumerator = this._microsummaries.Enumerate();
  184.  
  185.     // Show the drop marker if there are microsummaries; otherwise hide it.
  186.     // We do this via a microsummary picker-specific "droppable" attribute
  187.     // that, when set to "false", activates a "display: none" CSS rule
  188.     // on the drop marker.
  189.     if (enumerator.hasMoreElements())
  190.       microsummaryMenuList.setAttribute("droppable", "true");
  191.     else
  192.       microsummaryMenuList.setAttribute("droppable", "false");
  193.  
  194.     while (enumerator.hasMoreElements()) {
  195.       var microsummary = enumerator.getNext().QueryInterface(Ci.nsIMicrosummary);
  196.   
  197.       var menuItem = document.createElement("menuitem");
  198.   
  199.       // Store a reference to the microsummary in the menu item, so we know
  200.       // which microsummary this menu item represents when it's time to save
  201.       // changes to the datastore.
  202.       menuItem.microsummary = microsummary;
  203.   
  204.       // Content may have to be generated asynchronously; we don't necessarily
  205.       // have it now.  If we do, great; otherwise, fall back to the generator
  206.       // name, then the URI, and we trigger a microsummary content update.
  207.       // Once the update completes, the microsummary will notify our observer
  208.       // to rebuild the menu.
  209.       // XXX Instead of just showing the generator name or (heaven forbid)
  210.       // its URI when we don't have content, we should tell the user that we're
  211.       // loading the microsummary, perhaps with some throbbing to let her know
  212.       // it's in progress.
  213.       if (microsummary.content != null)
  214.         menuItem.setAttribute("label", microsummary.content);
  215.       else {
  216.         menuItem.setAttribute("label", microsummary.generator.name ?
  217.                                          microsummary.generator.name : microsummary.generator.uri.spec);
  218.         microsummary.update();
  219.       }
  220.  
  221.       microsummaryMenuPopup.appendChild(menuItem);
  222.   
  223.       // Select the item if this is the current microsummary for the bookmark.
  224.       if (this._bookmarkID && this._mss.isMicrosummary(this._bookmarkID, microsummary))
  225.         microsummaryMenuList.selectedItem = menuItem;
  226.  
  227.       // Activate the item if it was active before the rebuild (i.e. the user
  228.       // was hovering over it).
  229.       if (activeMicrosummary && microsummary == activeMicrosummary)
  230.         microsummaryMenuList.menuBoxObject.activeChild = menuItem;
  231.     }
  232.   },
  233.  
  234.   _observer: {
  235.     interfaces: [Ci.nsIMicrosummaryObserver, Ci.nsISupports],
  236.   
  237.     QueryInterface: function (iid) {
  238.       //if (!this.interfaces.some( function(v) { return iid.equals(v) } ))
  239.       if (!iid.equals(Ci.nsIMicrosummaryObserver) &&
  240.           !iid.equals(Ci.nsISupports))
  241.         throw Components.results.NS_ERROR_NO_INTERFACE;
  242.       return this;
  243.     },
  244.   
  245.     onContentLoaded: function(microsummary) {
  246.       MicrosummaryPicker.rebuild();
  247.     },
  248.   
  249.     onElementAppended: function(microsummary) {
  250.       MicrosummaryPicker.rebuild();
  251.     }
  252.   },
  253.  
  254.   /**
  255.    * Called when the user types in the microsummary picker's text box.
  256.    * 
  257.    * @param   event
  258.    *          the event object representing the input event
  259.    *
  260.    */
  261.   onInput: function MSP_onInput(event) {
  262.     this._updateUserEnteredNameItem();
  263.   },
  264.  
  265.   /**
  266.    * Update the menu item representing the user-entered name when the user
  267.    * changes the name by typing in the text box.
  268.    *
  269.    */
  270.   _updateUserEnteredNameItem: function MSP__updateUserEnteredNameItem() {
  271.     var nameField = document.getElementById("name");
  272.     var nameItem = document.getElementById("userEnteredNameItem");
  273.     nameItem.label = nameField.value;
  274.   },
  275.  
  276.   commit: function MSP_commit() {
  277.     var changed = false;
  278.     var menuList = document.getElementById("name");
  279.  
  280.     // Something should always be selected in the microsummary menu,
  281.     // but if nothing is selected, then conservatively assume we should
  282.     // just display the bookmark title.
  283.     if (menuList.selectedIndex == -1)
  284.       menuList.selectedIndex = 0;
  285.  
  286.     // This will set microsummary == undefined if the user selected
  287.     // the "don't display a microsummary" item.
  288.     var newMicrosummary = menuList.selectedItem.microsummary;
  289.  
  290.     if (newMicrosummary == null && this._mss.hasMicrosummary(this._bookmarkID)) {
  291.       this._mss.removeMicrosummary(this._bookmarkID);
  292.       changed = true;
  293.     }
  294.     else if (newMicrosummary != null
  295.              && !this._mss.isMicrosummary(this._bookmarkID, newMicrosummary)) {
  296.       this._mss.setMicrosummary(this._bookmarkID, newMicrosummary);
  297.       changed = true;
  298.     }
  299.  
  300.     return changed;
  301.   }
  302. };
  303.  
  304. function debug(str) {
  305.   dump(str + "\n");
  306. }
  307.